<template>
  <div class="app-container">
    <el-form :model="queryParams" ref="queryForm" size="small" :inline="true" v-show="showSearch" label-width="68px">
      <el-form-item label="路段名称" prop="roadName">
        <el-select v-model="queryParams.roadName" placeholder="请选择路段名称" clearable filterable>
          <el-option
            v-for="dict in dict.type.sys_road"
            :key="dict.value"
            :label="dict.label"
            :value="dict.value"
          />
        </el-select>
      </el-form-item>
      <!-- <el-form-item label="节点名称" prop="nodeName">
        <el-input
          v-model="queryParams.nodeName"
          placeholder="请输入节点名称"
          clearable
          @keyup.enter.native="handleQuery"
        />
      </el-form-item> -->
      <el-form-item>
	    <el-button type="primary" icon="el-icon-search" size="mini" @click="handleQuery">搜索</el-button>
        <el-button icon="el-icon-refresh" size="mini" @click="resetQuery">重置</el-button>
      </el-form-item>
    </el-form>

    <el-row :gutter="10" class="mb8">
      <el-col :span="1.5">
        <el-button
          type="primary"
          plain
          icon="el-icon-plus"
          size="mini"
          @click="handleAdd"
          v-hasPermi="['functiontest:TollAccessStatTest:add']"
        >新增</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="warning"
          plain
          icon="el-icon-download"
          size="mini"
          @click="handleExport"
          v-hasPermi="['functiontest:TollAccessStatTest:export']"
        >导出</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="info"
          plain
          icon="el-icon-upload"
          size="mini"
          @click="handleImport"
          v-hasPermi="['functiontest:TollAccessStatTest:import']"
        >导入</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="success"
          plain
          icon="el-icon-check"
          size="mini"
          @click="handleFieldAudit"
          v-hasPermi="['functiontest:TollAccessStatTest:fieldAudit']"
        >实测单位审核</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="primary"
          plain
          icon="el-icon-check"
          size="mini"
          @click="handleOwnerAudit"
          v-hasPermi="['functiontest:TollAccessStatTest:ownerAudit']"
        >业主审核</el-button>
      </el-col>
      <el-col :span="1.5">
        <el-button
          type="danger"
          plain
          icon="el-icon-check"
          size="mini"
          @click="handleCenterAudit"
          v-hasPermi="['functiontest:TollAccessStatTest:centerAudit']"
        >中心审核</el-button>
      </el-col>
     <!-- <el-col :span="1.5">
        <el-button
          type="info"
          plain
          icon="el-icon-sort"
          size="mini"
          @click="toggleExpandAll"
        >展开/折叠</el-button>
      </el-col>-->
      <right-toolbar :showSearch.sync="showSearch" @queryTable="getList"></right-toolbar>
    </el-row>

    <el-table
      v-if="refreshTable"
      v-loading="loading"
      :data="TollAccessStatTestList"
      row-key="id"
      :default-expand-all="isExpandAll"
      :tree-props="{children: 'children', hasChildren: 'hasChildren'}"
    >
      <el-table-column label="父节点ID" prop="parentId" />
      <el-table-column label="路段名称" align="center" prop="roadName">
        <template slot-scope="scope">
          <dict-tag :options="dict.type.sys_road" :value="scope.row.roadName"/>
        </template>
      </el-table-column>
      <el-table-column label="节点名称" align="center" prop="nodeName" />
      <el-table-column label="行车方向" align="center" prop="direction" />
      <el-table-column label="单向距离" align="center" prop="distance">
        <template slot-scope="scope">
          <span v-if="scope.row.distance">{{ scope.row.distance }}米</span>
        </template>
      </el-table-column>
      <el-table-column label="平均距离" align="center" prop="avgDistance">
        <template slot-scope="scope">
          <span v-if="scope.row.avgDistance">{{ scope.row.avgDistance }}米</span>
        </template>
      </el-table-column>
      <el-table-column label="图片" align="center" prop="image" width="100">
        <template slot-scope="scope">
          <image-preview v-if="isSecondLevelNode(scope.row)" :src="scope.row.image" :width="50" :height="50"/>
        </template>
      </el-table-column>
      <el-table-column label="备注" align="center" prop="remark" />
      <el-table-column label="操作" align="center" class-name="small-padding fixed-width">
        <template slot-scope="scope">
          <el-button
            size="mini"
            type="text"
            icon="el-icon-edit"
            @click="handleUpdate(scope.row)"
            v-hasPermi="['functiontest:TollAccessStatTest:edit']"
          >修改</el-button>
          <el-button
            size="mini"
            type="text"
            icon="el-icon-plus"
            @click="handleAdd(scope.row)"
            v-hasPermi="['functiontest:TollAccessStatTest:add']"
            v-if="canAddChild(scope.row)"
          >新增</el-button>
          <el-button
            size="mini"
            type="text"
            icon="el-icon-delete"
            @click="handleDelete(scope.row)"
            v-hasPermi="['functiontest:TollAccessStatTest:remove']"
          >删除</el-button>
        </template>
      </el-table-column>
    </el-table>

    <!-- 添加或修改联网收费切入数据实测统计测试对话框 -->
    <el-dialog :title="title" :visible.sync="open" width="500px" append-to-body>
      <el-form ref="form" :model="form" :rules="rules" label-width="80px">
        <el-form-item label="父节点ID" prop="parentId" v-show="false" v-if="!isSecondLevelNodeByParentId() && !isThirdLevelNodeByParentId() && !isFourthLevelNodeByParentId()">
          <treeselect v-model="form.parentId" :options="TollAccessStatTestOptions" :normalizer="normalizer" placeholder="请选择父节点ID" @select="onParentChange" />
        </el-form-item>
        
        <!-- 第一层节点：只显示路段名称 -->
        <el-form-item label="路段名称" prop="roadName" v-if="isFirstLevelNode()">
          <el-select v-model="form.roadName" placeholder="请选择路段名称" clearable filterable>
            <el-option
              v-for="dict in dict.type.sys_road"
              :key="dict.value"
              :label="dict.label"
              :value="dict.value"
            ></el-option>
          </el-select>
        </el-form-item>

        <!-- 第三层节点：只显示节点名称 -->
        <el-form-item label="节点名称" prop="nodeName" v-if="isThirdLevelNodeByParentId()">
          <el-input v-model="form.nodeName" placeholder="请输入节点名称" />
        </el-form-item>
        
        <!-- 第二层节点：只显示图片上传 -->
        <el-form-item label="图片" prop="image" v-if="isSecondLevelNodeByParentId()">
          <image-upload v-model="form.image"/>
        </el-form-item>
        
        <!-- 第四层节点：显示行车方向、单向距离、备注 -->
        <el-form-item label="行车方向" prop="direction" v-if="isFourthLevelNodeByParentId() && !isThirdLevelNodeByParentId()">
          <el-input v-model="form.direction" placeholder="请输入行车方向" />
        </el-form-item>
        <el-form-item label="单向距离" prop="distance" v-if="isFourthLevelNodeByParentId() && !isThirdLevelNodeByParentId()">
          <el-input v-model="form.distance" placeholder="请输入单向距离" />
        </el-form-item>
        <el-form-item label="备注" prop="remark" v-if="isFourthLevelNodeByParentId() && !isThirdLevelNodeByParentId()">
          <el-input v-model="form.remark" placeholder="请输入备注" />
        </el-form-item>
        
        <!-- 平均距离字段（仅在第三层和第四层节点时显示） -->
        <el-form-item label="平均距离" prop="avgDistance" v-if="(isThirdLevelNodeByParentId() || isFourthLevelNodeByParentId()) && !isSecondLevelNodeByParentId() && !isThirdLevelNodeByParentId() && !isFourthLevelNodeByParentId()">
          <el-input v-model="form.avgDistance" placeholder="请输入平均距离" />
        </el-form-item>
      </el-form>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="submitForm">确 定</el-button>
        <el-button @click="cancel">取 消</el-button>
      </div>
    </el-dialog>

    <!-- 导入对话框 -->
    <el-dialog :title="upload.title" :visible.sync="upload.open" width="400px" append-to-body>
      <el-upload
        ref="upload"
        :limit="1"
        accept=".xlsx, .xls"
        :headers="upload.headers"
        :action="upload.url + '?updateSupport=' + upload.updateSupport"
        :disabled="upload.isUploading"
        :on-progress="handleFileUploadProgress"
        :on-success="handleFileSuccess"
        :auto-upload="false"
        drag
      >
        <i class="el-icon-upload"></i>
        <div class="el-upload__text">将文件拖到此处，或<em>点击上传</em></div>
        <div class="el-upload__tip text-center" slot="tip">
          <div class="el-upload__tip" slot="tip">
            <el-checkbox v-model="upload.updateSupport" />是否更新已经存在的数据
          </div>
          <span>仅允许导入xls、xlsx格式文件。</span>
          <el-link type="primary" :underline="false" style="font-size:12px;vertical-align: baseline;" @click="importTemplate">下载模板</el-link>
        </div>
      </el-upload>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="submitFileForm">确 定</el-button>
        <el-button @click="upload.open = false">取 消</el-button>
      </div>
    </el-dialog>
  </div>
</template>

<script>
import { listTollAccessStatTest, getTollAccessStatTest, delTollAccessStatTest, addTollAccessStatTest, updateTollAccessStatTest, exportTollAccessStatTest, importTollAccessStatTest, importTemplateTollAccessStatTest, updateReview1ToZero, checkAllReview1IsZero, updateReview2ToZeroByCondition, checkAllReview1AndReview2AreZero, updateReview3ToZero } from "@/api/functiontest/TollAccessStatTest"
import Treeselect from "@riophae/vue-treeselect"
import ImagePreview from "@/components/ImagePreview"
import "@riophae/vue-treeselect/dist/vue-treeselect.css"
import { getUserProfile } from "@/api/system/user"

export default {
  name: "TollAccessStatTest",
  dicts: ['sys_road'],
  components: {
    Treeselect,
    ImagePreview
  },
  data() {
    return {
      // 遮罩层
      loading: true,
      // 显示搜索条件
      showSearch: true,
      // 联网收费切入数据实测统计测试表格数据
      TollAccessStatTestList: [],
      // 联网收费切入数据实测统计测试树选项
      TollAccessStatTestOptions: [],
      // 弹出层标题
      title: "",
      // 是否显示弹出层
      open: false,
      // 是否展开，默认全部展开
      isExpandAll: false,
      // 重新渲染表格状态
      refreshTable: true,
      // 查询参数
      queryParams: {
        roadName: null,
        nodeName: null,
        deptId: null,
        roleId: null,
      },
      // 表单参数
      form: {},
      // 表单校验
      rules: {
      },
      deptId: null,
      roleId: null,
      // 上传参数
      upload: {
        // 是否显示弹出层（用户导入）
        open: false,
        // 弹出层标题（用户导入）
        title: "",
        // 是否禁用上传
        isUploading: false,
        // 是否更新已经存在的用户数据
        updateSupport: 0,
        // 设置上传的请求头部
        headers: { Authorization: "Bearer " + this.$store.getters.token },
        // 上传的地址
        url: process.env.VUE_APP_BASE_API + "/functiontest/TollAccessStatTest/importData"
      },
    }
  },
  created() {
    this.getUser().then(() => {
      this.getList();
    });
  },
  watch: {
    // 监听form.parentId的变化，确保界面能及时更新
    'form.parentId': {
      handler(newVal, oldVal) {
        // 当parentId变化时，强制更新界面
        this.$forceUpdate();
      },
      immediate: true
    }
  },
  methods: {
    getUser() {
      return getUserProfile().then(response => {
        if(response.data.roles[0].roleId != 1) {
          this.deptId = response.data.dept.deptId
        }else{
          this.deptId = null
        }
        this.roleId = response.data.roles[0].roleId
      })
    },
    /** 查询联网收费切入数据实测统计测试列表 */
    getList() {
      this.queryParams.deptId = this.deptId
      this.queryParams.roleId = this.roleId
      this.loading = true
      listTollAccessStatTest(this.queryParams).then(response => {
        this.TollAccessStatTestList = this.handleTree(response.data, "id", "parentId")
        this.loading = false
      })
    },
    /** 转换联网收费切入数据实测统计测试数据结构 */
    normalizer(node) {
      if (node.children && !node.children.length) {
        delete node.children
      }
      return {
        id: node.id,
        label: node.nodeName,
        children: node.children
      }
    },
	/** 查询联网收费切入数据实测统计测试下拉树结构 */
    getTreeselect() {
      listTollAccessStatTest().then(response => {
        this.TollAccessStatTestOptions = []
        const data = { id: 0, nodeName: '顶级节点', children: [] }
        data.children = this.handleTree(response.data, "id", "parentId")
        this.TollAccessStatTestOptions.push(data)
      })
    },
    // 取消按钮
    cancel() {
      this.open = false
      this.reset()
    },
    // 表单重置
    reset() {
      this.form = {
        id: null,
        parentId: null,
        roadName: null,
        nodeName: null,
        direction: null,
        distance: null,
        avgDistance: null,
        image: null,
        remark: null
      }
      this.resetForm("form")
    },
    /** 搜索按钮操作 */
    handleQuery() {
      this.getList()
    },
    /** 重置按钮操作 */
    resetQuery() {
      this.resetForm("queryForm")
      this.handleQuery()
    },
    /** 新增按钮操作 */
    handleAdd(row) {
      this.reset()
      this.getTreeselect()
      if (row != null && row.id) {
        this.form.parentId = row.id
      } else {
        this.form.parentId = 0
      }
      this.open = true
      this.title = "添加联网收费切入数据实测统计测试"
      // 强制更新界面以确保条件渲染正确执行
      this.$nextTick(() => {
        this.$forceUpdate()
      })
    },
    /** 展开/折叠操作 */
    toggleExpandAll() {
      this.refreshTable = false
      this.isExpandAll = !this.isExpandAll
      this.$nextTick(() => {
        this.refreshTable = true
      })
    },
    /** 修改按钮操作 */
    handleUpdate(row) {
      this.reset()
      this.getTreeselect()
      if (row != null) {
        this.form.parentId = row.parentId
      }
      getTollAccessStatTest(row.id).then(response => {
        this.form = response.data
        this.open = true
        this.title = "修改联网收费切入数据实测统计测试"
        // 强制更新界面以确保条件渲染正确执行
        this.$nextTick(() => {
          this.$forceUpdate()
        })
      })
    },
    /** 提交按钮 */
    submitForm() {
      this.$refs["form"].validate(valid => {
        if (valid) {
          if (this.form.id != null) {
            // 修改节点
            updateTollAccessStatTest(this.form).then(response => {
              this.$modal.msgSuccess("修改成功")
              // 先刷新列表，然后再计算平均距离
              this.getList()
              // 然后在修改后计算平均距离
              this.calculateAvgDistance();
              // 在计算平均距离完成后再关闭对话框
              this.open = false
            })
          } else {
            // 新增节点
            addTollAccessStatTest(this.form).then(response => {
              this.$modal.msgSuccess("新增成功")
              // 先刷新列表，然后再计算平均距离
              this.getList()
              // 然后在新增后计算平均距离
              this.calculateAvgDistanceAfterAdd(response.data.id);
              // 在计算平均距离完成后再关闭对话框
              this.open = false
            })
          }
        }
      })
    },
    /** 删除按钮操作 */
    handleDelete(row) {
      const parentId = row.parentId; // 保存父节点ID用于计算平均距离
      this.$modal.confirm('是否确认删除联网收费切入数据实测统计测试编号为"' + row.id + '"的数据项？').then(function() {
        return delTollAccessStatTest(row.id)
      }).then(() => {
        // 先显示成功消息
        this.$modal.msgSuccess("删除成功")
        
        // 先刷新列表，然后再计算平均距离
        this.getList()
        
        // 然后删除成功后计算平均距离
        if (parentId !== 0 && parentId !== null) {
          this.calculateAvgDistanceAfterDelete(row.id, parentId);
        }
      }).catch(() => {})
    },
    /** 导出按钮操作 */
    handleExport() {
      const queryParams = this.queryParams;
      this.$modal.confirm('是否确认导出所有联网收费切入数据实测统计测试数据项？').then(() => {
        return exportTollAccessStatTest(queryParams);
      }).then(response => {
        this.download(response, '联网收费切入数据实测统计测试数据.xlsx');
      }).catch(() => {});
    },
    /** 下载文件 */
    download(data, fileName) {
      const blob = new Blob([data], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
      const url = window.URL.createObjectURL(blob);
      const link = document.createElement('a');
      link.style.display = 'none';
      link.href = url;
      link.setAttribute('download', fileName);
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
      window.URL.revokeObjectURL(url);
    },
    /** 判断是否为第二层节点 */
    isSecondLevelNode(row) {
      // 查找当前行的父节点
      const findParent = (nodes, parentId) => {
        for (let node of nodes) {
          if (node.id === parentId) {
            return node;
          }
          if (node.children && node.children.length > 0) {
            const found = findParent(node.children, parentId);
            if (found) {
              return found;
            }
          }
        }
        return null;
      };
      
      // 查找当前行的父节点
      const parent = findParent(this.TollAccessStatTestList, row.parentId);
      
      // 如果父节点存在且父节点的parentId为0，则当前行是二级节点
      return parent && parent.parentId === 0;
    },
    /** 通过parentId判断是否为第二层节点 */
    isSecondLevelNodeByParentId() {
      // 第二层节点的特征：父节点parentId为0，且当前节点parentId不为0
      if (this.form.parentId === 0 || this.form.parentId === null) {
        return false;
      }
      
      // 如果父节点ID为0，说明当前节点是第二层节点
      if (this.form.parentId === 0) {
        return true;
      }
      
      // 查找父节点
      const findParent = (nodes, parentId) => {
        for (let node of nodes) {
          if (node.id === parentId) {
            return node;
          }
          if (node.children && node.children.length > 0) {
            const found = findParent(node.children, parentId);
            if (found) {
              return found;
            }
          }
        }
        return null;
      };
      
      // 查找当前表单节点的父节点
      const parent = findParent(this.TollAccessStatTestList, this.form.parentId);
      
      // 如果父节点存在且父节点的parentId为0，则当前节点是第二层节点
      return parent && parent.parentId === 0;
    },
    /** 通过parentId判断是否为第三层节点 */
    isThirdLevelNodeByParentId() {
      // 第三层节点的特征：祖父节点parentId为0，且当前节点parentId不为0
      if (this.form.parentId === 0 || this.form.parentId === null) {
        return false;
      }
      
      // 查找父节点和祖父节点
      const findParent = (nodes, parentId) => {
        for (let node of nodes) {
          if (node.id === parentId) {
            return node;
          }
          if (node.children && node.children.length > 0) {
            const found = findParent(node.children, parentId);
            if (found) {
              return found;
            }
          }
        }
        return null;
      };
      
      // 查找当前表单节点的父节点
      const parent = findParent(this.TollAccessStatTestList, this.form.parentId);
      
      // 如果父节点不存在，返回false
      if (!parent) {
        return false;
      }
      
      // 如果父节点的parentId为0，说明当前节点是第三层节点
      if (parent.parentId === 0) {
        return true;
      }
      
      // 查找祖父节点
      const grandParent = findParent(this.TollAccessStatTestList, parent.parentId);
      
      // 如果祖父节点存在且祖父节点的parentId为0，则当前节点是第三层节点
      return grandParent && grandParent.parentId === 0;
    },
    /** 通过parentId判断是否为第四层节点 */
    isFourthLevelNodeByParentId() {
      // 第四层节点的特征：曾祖父节点parentId为0，且当前节点parentId不为0
      if (this.form.parentId === 0 || this.form.parentId === null) {
        return false;
      }
      
      // 查找父节点、祖父节点和曾祖父节点
      const findParent = (nodes, parentId) => {
        for (let node of nodes) {
          if (node.id === parentId) {
            return node;
          }
          if (node.children && node.children.length > 0) {
            const found = findParent(node.children, parentId);
            if (found) {
              return found;
            }
          }
        }
        return null;
      };
      
      // 查找当前表单节点的父节点
      const parent = findParent(this.TollAccessStatTestList, this.form.parentId);
      
      // 如果父节点不存在，返回false
      if (!parent) {
        return false;
      }
      
      // 查找祖父节点
      const grandParent = findParent(this.TollAccessStatTestList, parent.parentId);
      
      // 如果祖父节点不存在，返回false
      if (!grandParent) {
        return false;
      }
      
      // 如果祖父节点的parentId为0，说明当前节点是第四层节点
      if (grandParent.parentId === 0) {
        return true;
      }
      
      // 查找曾祖父节点
      const greatGrandParent = findParent(this.TollAccessStatTestList, grandParent.parentId);
      
      // 如果曾祖父节点存在且parentId为0，则当前节点是第四层节点
      return greatGrandParent && greatGrandParent.parentId === 0;
    },
    /** 判断是否为第一层节点 */
    isFirstLevelNode() {
      return !this.form.parentId || this.form.parentId === 0
    },
    /** 判断是否允许在当前行添加子节点（第四层节点不显示新增按钮） */
    canAddChild(row) {
      // 查找当前行的父节点、祖父节点和曾祖父节点
      const findParent = (nodes, parentId) => {
        for (let node of nodes) {
          if (node.id === parentId) {
            return node;
          }
          if (node.children && node.children.length > 0) {
            const found = findParent(node.children, parentId);
            if (found) {
              return found;
            }
          }
        }
        return null;
      };
      
      // 查找当前行的父节点
      const parent = findParent(this.TollAccessStatTestList, row.parentId);
      if (!parent) {
        // 如果没有父节点，说明是顶级节点，可以添加
        return true;
      }
      
      // 查找祖父节点
      const grandParent = findParent(this.TollAccessStatTestList, parent.parentId);
      if (!grandParent) {
        // 如果没有祖父节点，说明是二级节点，可以添加
        return true;
      }
      
      // 查找曾祖父节点
      const greatGrandParent = findParent(this.TollAccessStatTestList, grandParent.parentId);
      if (!greatGrandParent) {
        // 如果没有曾祖父节点，说明是三级节点，可以添加
        return true;
      }
      
      // 如果存在曾祖父节点，说明当前节点是四级节点，不允许添加子节点
      return false;
    },
    /** 处理父节点选择变化事件 */
    onParentChange(selectedNode) {
      // 当父节点选择发生变化时，强制更新界面
      this.$forceUpdate();
    },
    /** 计算平均距离 */
    calculateAvgDistance() {
      // 只有当当前节点有父节点时才需要计算平均距离
      if (this.form.parentId !== 0 && this.form.parentId !== null) {
        // 获取完整的树结构数据
        listTollAccessStatTest().then(response => {
          const fullTreeData = this.handleTree(response.data, "id", "parentId");
          
          // 查找节点的函数
          const findNode = (nodes, targetId) => {
            for (let node of nodes) {
              if (node.id === targetId) {
                return node;
              }
              if (node.children && node.children.length > 0) {
                const found = findNode(node.children, targetId);
                if (found) {
                  return found;
                }
              }
            }
            return null;
          };
          
          // 查找当前表单节点的父节点
          const parentNode = findNode(fullTreeData, this.form.parentId);
          
          // 确保父节点存在
          if (parentNode) {
            // 查找父节点的父节点
            const grandParentNode = findNode(fullTreeData, parentNode.parentId);
            
            // 确保父节点的父节点存在
            if (grandParentNode) {
              // 查找父节点的父节点的父节点
              const greatGrandParentNode = findNode(fullTreeData, grandParentNode.parentId);
              
              // 如果父节点的父节点的父节点存在且parentId为0，则当前节点是四级节点
              // 父节点是三级节点，父节点的父节点是二级节点，父节点的父节点的父节点是一级节点
              if (greatGrandParentNode && greatGrandParentNode.parentId === 0) {
                // 当前正在编辑的是四级节点，需要计算其兄弟节点（同为四级节点）的平均距离
                // 并更新其父节点（三级节点）的平均距离
                
                // 获取所有兄弟节点（包括当前节点）
                const siblingNodes = parentNode.children || [];
                
                // 过滤出有distance值的节点
                const nodesWithDistance = siblingNodes.filter(node => 
                  node.distance !== null && node.distance !== undefined && !isNaN(parseFloat(node.distance))
                );
                
                // 计算平均距离
                let avgDistance = 0;
                if (nodesWithDistance.length > 0) {
                  const totalDistance = nodesWithDistance.reduce((sum, node) => 
                    sum + parseFloat(node.distance), 0);
                  avgDistance = totalDistance / nodesWithDistance.length;
                }
                
                // 更新父节点（三级节点）的平均距离
                parentNode.avgDistance = parseFloat(avgDistance.toFixed(2));
                
                // 更新父节点的平均距离到数据库
                const parentForm = {
                  id: parentNode.id,
                  avgDistance: parentNode.avgDistance
                };
                
                // 调用更新接口更新父节点
                updateTollAccessStatTest(parentForm).then(response => {
                  // 更新成功后刷新列表
                  this.getList();
                }).catch(error => {
                  console.error("三级节点平均距离更新失败:", error);
                  this.$modal.msgError("三级节点平均距离更新失败");
                  // 即使更新失败也刷新列表
                  this.getList();
                });
              } else {
                // 如果不是四级节点，直接刷新列表
                this.getList();
              }
            } else {
              // 如果没有祖父节点，直接刷新列表
              this.getList();
            }
          } else {
            // 如果没有找到父节点，直接刷新列表
            this.getList();
          }
        }).catch(error => {
          console.error("获取完整树结构数据失败:", error);
          this.$modal.msgError("获取数据失败，无法计算平均距离");
          // 即使获取数据失败也刷新列表
          this.getList();
        });
      } else {
        // 如果没有父节点，直接刷新列表
        this.getList();
      }
    },
    /** 新增后重新计算平均距离 */
    calculateAvgDistanceAfterAdd(newNodeId) {
      // 获取完整的树结构数据，包括刚刚新增的节点
      listTollAccessStatTest().then(response => {
        const fullTreeData = this.handleTree(response.data, "id", "parentId");
        
        // 查找节点的函数
        const findNode = (nodes, targetId) => {
          for (let node of nodes) {
            if (node.id === targetId) {
              return node;
            }
            if (node.children && node.children.length > 0) {
              const found = findNode(node.children, targetId);
              if (found) {
                return found;
              }
            }
          }
          return null;
        };
        
        // 查找新增的节点
        const newNode = findNode(fullTreeData, newNodeId);
        
        // 确保新增节点存在
        if (newNode) {
          // 查找新增节点的父节点
          const parentNode = findNode(fullTreeData, newNode.parentId);
          
          // 确保父节点存在
          if (parentNode) {
            // 查找父节点的父节点
            const grandParentNode = findNode(fullTreeData, parentNode.parentId);
            
            // 确保父节点的父节点存在
            if (grandParentNode) {
              // 查找父节点的父节点的父节点
              const greatGrandParentNode = findNode(fullTreeData, grandParentNode.parentId);
              
              // 如果父节点的父节点的父节点存在且parentId为0，则当前节点是四级节点
              // 父节点是三级节点，父节点的父节点是二级节点，父节点的父节点的父节点是一级节点
              if (greatGrandParentNode && greatGrandParentNode.parentId === 0) {
                // 当前新增的是四级节点，需要计算其兄弟节点（同为四级节点）的平均距离
                // 并更新其父节点（三级节点）的平均距离
                
                // 获取所有兄弟节点（包括当前新增节点）
                const siblingNodes = parentNode.children || [];
                
                // 过滤出有distance值的节点
                const nodesWithDistance = siblingNodes.filter(node => 
                  node.distance !== null && node.distance !== undefined && !isNaN(parseFloat(node.distance))
                );
                
                // 计算平均距离
                let avgDistance = 0;
                if (nodesWithDistance.length > 0) {
                  const totalDistance = nodesWithDistance.reduce((sum, node) => 
                    sum + parseFloat(node.distance), 0);
                  avgDistance = totalDistance / nodesWithDistance.length;
                }
                
                // 更新父节点（三级节点）的平均距离
                parentNode.avgDistance = parseFloat(avgDistance.toFixed(2));
                
                // 更新父节点的平均距离到数据库
                const parentForm = {
                  id: parentNode.id,
                  avgDistance: parentNode.avgDistance
                };
                
                // 调用更新接口更新父节点
                updateTollAccessStatTest(parentForm).then(response => {
                  // 更新成功后刷新列表
                  this.getList();
                }).catch(error => {
                  console.error("三级节点平均距离更新失败:", error);
                  this.$modal.msgError("三级节点平均距离更新失败");
                  // 即使更新失败也刷新列表
                  this.getList();
                });
              } else {
                // 如果不是四级节点，直接刷新列表
                this.getList();
              }
            } else {
              // 如果没有祖父节点，直接刷新列表
              this.getList();
            }
          } else {
            // 如果没有找到父节点，直接刷新列表
            this.getList();
          }
        } else {
          // 如果没有找到新增节点，直接刷新列表
          this.getList();
        }
      }).catch(error => {
        console.error("获取完整树结构数据失败:", error);
        this.$modal.msgError("获取数据失败，无法计算平均距离");
        // 即使获取数据失败也刷新列表
        this.getList();
      }).finally(() => {
        // 确保无论如何都会刷新列表
        this.getList();
      });
    },
    /** 删除后重新计算平均距离 */
    calculateAvgDistanceAfterDelete(deletedNodeId, parentNodeId) {
      // 获取完整的树结构数据，不包括刚刚删除的节点
      listTollAccessStatTest().then(response => {
        const fullTreeData = this.handleTree(response.data, "id", "parentId");
        
        // 查找节点的函数
        const findNode = (nodes, targetId) => {
          for (let node of nodes) {
            if (node.id === targetId) {
              return node;
            }
            if (node.children && node.children.length > 0) {
              const found = findNode(node.children, targetId);
              if (found) {
                return found;
              }
            }
          }
          return null;
        };
        
        // 查找删除节点的父节点
        const parentNode = findNode(fullTreeData, parentNodeId);
        
        // 确保父节点存在
        if (parentNode) {
          // 查找父节点的父节点
          const grandParentNode = findNode(fullTreeData, parentNode.parentId);
          
          // 确保父节点的父节点存在
          if (grandParentNode) {
            // 查找父节点的父节点的父节点
            const greatGrandParentNode = findNode(fullTreeData, grandParentNode.parentId);
            
            // 如果父节点的父节点的父节点存在且parentId为0，则当前节点是四级节点
            // 父节点是三级节点，父节点的父节点是二级节点，父节点的父节点的父节点是一级节点
            if (greatGrandParentNode && greatGrandParentNode.parentId === 0) {
              // 当前删除的是四级节点，需要计算其兄弟节点（同为四级节点）的平均距离
              // 并更新其父节点（三级节点）的平均距离
              
              // 获取所有兄弟节点（不包括当前删除节点）
              const siblingNodes = parentNode.children || [];
              
              // 过滤出有distance值的节点
              const nodesWithDistance = siblingNodes.filter(node => 
                node.distance !== null && node.distance !== undefined && !isNaN(parseFloat(node.distance))
              );
              
              // 计算平均距离
              let avgDistance = 0;
              if (nodesWithDistance.length > 0) {
                const totalDistance = nodesWithDistance.reduce((sum, node) => 
                  sum + parseFloat(node.distance), 0);
                avgDistance = totalDistance / nodesWithDistance.length;
              }
              
              // 更新父节点（三级节点）的平均距离
              parentNode.avgDistance = parseFloat(avgDistance.toFixed(2));
              
              // 更新父节点的平均距离到数据库
              const parentForm = {
                id: parentNode.id,
                avgDistance: parentNode.avgDistance
              };
              
              // 调用更新接口更新父节点
              updateTollAccessStatTest(parentForm).then(response => {
                // 更新成功后刷新列表
                this.getList();
              }).catch(error => {
                console.error("三级节点平均距离更新失败:", error);
                this.$modal.msgError("三级节点平均距离更新失败");
                // 即使更新失败也刷新列表
                this.getList();
              });
            } else {
              // 如果不是四级节点，直接刷新列表
              this.getList();
            }
          } else {
            // 如果没有祖父节点，直接刷新列表
            this.getList();
          }
        } else {
          // 如果没有找到父节点，直接刷新列表
          this.getList();
        }
      }).catch(error => {
        console.error("获取完整树结构数据失败:", error);
        this.$modal.msgError("获取数据失败，无法计算平均距离");
        // 即使获取数据失败也刷新列表
        this.getList();
      }).finally(() => {
        // 确保无论如何都会刷新列表
        this.getList();
      });
    }
  }
}
</script>

<style scoped>
/* 自定义样式 */
.custom-tree-table {
  margin-top: 20px;
}

.search-form {
  margin-bottom: 20px;
}

.operation-buttons {
  margin-bottom: 20px;
}

.tree-table-container {
  background: #fff;
  padding: 20px;
  border-radius: 4px;
  box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.1);
}

.dialog-form {
  padding: 20px 0;
}

.form-item {
  margin-bottom: 18px;
}

/* 树形表格样式 */
.tree-table >>> .el-table__row {
  cursor: pointer;
}

.tree-table >>> .el-table__row:hover {
  background-color: #f5f7fa;
}

/* 节点层级样式 */
.level-1 {
  font-weight: bold;
  color: #409EFF;
}

.level-2 {
  font-weight: 600;
  color: #67C23A;
}

.level-3 {
  color: #E6A23C;
}

.level-4 {
  color: #909399;
}

/* 距离值样式 */
.distance-value {
  font-weight: 600;
  color: #F56C6C;
}

.avg-distance {
  font-weight: 600;
  color: #409EFF;
  background-color: #ecf5ff;
  padding: 2px 6px;
  border-radius: 3px;
}

/* 操作按钮样式 */
.operation-cell {
  white-space: nowrap;
}

.operation-cell .el-button {
  margin-right: 5px;
}

.operation-cell .el-button:last-child {
  margin-right: 0;
}

/* 响应式调整 */
@media screen and (max-width: 768px) {
  .search-form .el-form-item {
    margin-bottom: 15px;
  }
  
  .operation-buttons .el-button {
    margin-bottom: 10px;
  }
}
</style>
